collector.add(key, value, dest);
            return Value.present();
        }

        @Override
        public Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collector, ImmutableCollection.Builder<K> dest) {
            collector.add(key, dest);
            return Value.present();
        }

        @Override

        def dest = temporaryFolder.file("dir/dest")

        when:
        new TestFileTreeElement(src, chmod).copyTo(dest)

        then:
        dest.assertIsFile()
        dest.getText() == "content"
    }

    def copiedFileHasExpectedPermissions() throws Exception {
        given:
        def src = writeToFile("src", "")
        final dest = temporaryFolder.file("dest")

        when:

        @Override
        public void add(@Nullable Object value, ImmutableCollection.Builder<Object> dest) {
            dest.add(value);
        }

        @Override
        public void addAll(Iterable<?> values, ImmutableCollection.Builder<Object> dest) {
            dest.addAll(values);
        }
    };
    private static final ValueCollector<Object> STRING_VALUE_COLLECTOR = new ValueCollector<Object>() {

        with:
          distribution: 'zulu'
          java-version: 17

      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v3

      - name: Run Checks
        run: ./gradlew test -Dtest.java.version=11

      - name: Publish Test Report
        if: github.repository == 'square/okhttp' && github.ref == 'refs/heads/master'
        uses: mikepenz/action-junit-report@v4
        with:

		}

		dest := new(packedInts)
		if err := unmarshal(tc.encoded, dest); err != nil {
			t.Errorf("failed decode %d: %v", i, err)
			continue
		}
		if got, want := dest.uint64s, tc.uint64s; !reflect.DeepEqual(got, want) {
			t.Errorf("failed decode uint64s %d, got %v, want %v", i, got, want)
		}
		if got, want := dest.int64s, tc.int64s; !reflect.DeepEqual(got, want) {

                collectionType.getName(), elementType.getName(), value.getClass().getName()));
        }
        dest.add(sanitized);
    }

    @Override
    public void addAll(Iterable<? extends T> values, ImmutableCollection.Builder<T> dest) {
        for (T value : values) {
            add(value, dest);
        }
    }

			given: func() Mapper {
				// root (dest port):
				//   <no matches>
				//   fallback (dest ip):
				//     1.2.3.4: chain
				fallback := NewDestinationIP()
				fallback.Map["1.2.3.4"] = ToChain("chain")

				root := NewDestinationPort()
				root.OnNoMatch = ToMatcher(fallback.Matcher)
				return root
			},
			want: func() *matcher.Matcher {
				// root (dest ip):
				//   1.2.3.4: chain

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build plan9

package fdtest

import (
	"syscall"
)

const errBadFd = syscall.ErrorString("fd out of range or not open")

// Exists returns true if fd is a valid file descriptor.
func Exists(fd uintptr) bool {
	var buf [1]byte
	_, err := syscall.Fstat(int(fd), buf[:])

	}
	df, err := os.Create(dest)
	if err != nil {
		return fmt.Errorf("unable to create destination file [%s]: %q", dest, err)
	}
	defer df.Close()

	_, err = io.Copy(df, sf)
	if err != nil {
		return fmt.Errorf("unable to copy [%s] to [%s]: %q", source, dest, err)
	}

	if err := os.Chmod(dest, fi.Mode()); err != nil {
		return fmt.Errorf("unable to close destination file: %q", err)
	}

        final TestResultProcessor processor;
        final TestOutputEvent.Destination dest;
        Object outputOwner;

        public Forwarder(TestResultProcessor processor, TestOutputEvent.Destination dest) {
            this.processor = processor;
            this.dest = dest;
        }

        @Override
        public void onOutput(CharSequence output) {
            if (outputOwner == null) {