File remoteFile = new File(basedir, path(download.getArtifact()));
                try {
                    Path dest = download.getPath();
                    Files.createDirectories(dest.getParent());
                    Files.copy(remoteFile.toPath(), dest);
                } catch (IOException e) {
                    if (!remoteFile.exists()) {

ISTIO_DEB_DEST:=${ISTIO_DEB_BIN}/istio-start.sh \
		/lib/systemd/system/istio.service \
		/var/lib/istio/envoy/sidecar.env

$(foreach DEST,$(ISTIO_DEB_DEST),\
        $(eval ${TARGET_OUT_LINUX}/istio-sidecar.deb:   tools/packaging/common/$(notdir $(DEST))) \
        $(eval SIDECAR_FILES+=${REPO_ROOT}/tools/packaging/common/$(notdir $(DEST))=$(DEST)))

SIDECAR_FILES+=${REPO_ROOT}/tools/packaging/common/envoy_bootstrap.json=/var/lib/istio/envoy/envoy_bootstrap_tmpl.json

limitations under the License.
*/

package main

import (
	"github.com/mrunalp/fileutils"
)

func copyDirectory(source string, dest string) error {
	return fileutils.CopyDirectory(source, dest)

commands: [{
  executable: gradle
  args: "--rerun-tasks someTask -DsomeDestination=dest"
  expected-output-file: store.out
  allow-additional-output: true
}, {
  executable: gradle
  args: "--rerun-tasks someTask -DsomeDestination=dest"
  expected-output-file: load.out
  allow-additional-output: true
}, {
   executable: gradle
   args: "--rerun-tasks someTask -DsomeDestination=another"
   expected-output-file: load-another.out

commands: [{
  executable: gradle
  args: "--rerun-tasks someTask -DsomeDestination=dest"
  expected-output-file: store.out
  allow-additional-output: true
}, {
  executable: gradle
  args: "--rerun-tasks someTask -DsomeDestination=dest"
  expected-output-file: load.out
  allow-additional-output: true
}, {
   executable: gradle
   args: "--rerun-tasks someTask -DsomeDestination=another"
   expected-output-file: store-another.out

  /**
   * Copies bytes from this hash code into {@code dest}.
   *
   * @param dest the byte array into which the hash code will be written
   * @param offset the start offset in the data
   * @param maxLength the maximum number of bytes to write
   * @return the number of bytes written to {@code dest}
   * @throws IndexOutOfBoundsException if there is not enough room in {@code dest}
   */
  @CanIgnoreReturnValue

        def src = new DefaultResourceAwareResolveResult()
        src.attempted("a")
        src.attempted("b")
        def dest = new DefaultResourceAwareResolveResult()

        when:
        src.applyTo(dest)

        then:
        dest.attempted == ["a", "b"]
    }

func (c *Converter) Convert(src, dest interface{}, meta *Meta) error {
	pair := typePair{reflect.TypeOf(src), reflect.TypeOf(dest)}
	scope := &scope{
		converter: c,
		meta:      meta,
	}

	// ignore conversions of this type
	if _, ok := c.ignoredUntypedConversions[pair]; ok {
		return nil
	}
	if fn, ok := c.conversionFuncs.untyped[pair]; ok {
		return fn(src, dest, scope)
	}

import javax.annotation.Nullable;

public interface ValueCollector<T> {
    void add(@Nullable T value, ImmutableCollection.Builder<T> dest);

    void addAll(Iterable<? extends T> values, ImmutableCollection.Builder<T> dest);

        def block2 = write("test 2")

        def copy1 = storeAndLoad(block1)
        def copy2 = storeAndLoad(block2)

        def dest = store()
        dest.read(copy2) == "test 2"
        dest.read(copy1) == "test 1"

        cleanup:
        dest?.close()
    }

    def "does not overwrite blocks written by previous instances"() {
        expect:
        def block1 = write("test 1")