}
                dest.add(v);
            }
        }
        return dest;
    }

    @Deprecated
    public static <V, T extends Collection<? super V>> T addToCollection(T dest, Iterable<? extends V>... srcs) {
        return addToCollection(dest, false, srcs);
    }

    public static Comparator<String> caseInsensitive() {
        return new Comparator<String>() {

	var output []byte
	var err error
	filename := "ptrsort.go"
	exename := "ptrsort"
	outname := "ptrsort.out"
	gotool := testenv.GoToolPath(t)
	dest := filepath.Join(t.TempDir(), exename)
	cmd := testenv.Command(t, gotool, "build", "-o", dest, filepath.Join("testdata", filename))
	if output, err = cmd.CombinedOutput(); err != nil {
		t.Fatalf("Failed: %v:\nOutput: %s\n", err, output)
	}

        }

        dest.put(sanitizedKey, sanitizedValue);
    }

    @Override
    public void addAll(Iterable<? extends Map.Entry<? extends K, ? extends V>> entries, Map<K, V> dest) {
        for (Map.Entry<? extends K, ? extends V> entry : entries) {
            add(entry.getKey(), entry.getValue(), dest);
        }
    }

        }

        file("dest").with {
            createFile("subdir/included.txt")
            createFile("subdir/extra.txt")
            createFile("included.txt")
            createFile("extra.txt")
            createDir("extra")
        }

        when:
        def result = copier.sync({
            it.from "src"
            it.into "dest"
        } as Action)

        then:

    }

    private void sourceSetDirectoriesAreEmptySet() {
        1 * sourceSetDirectories.getFiles() >> []
    }

    def destFile() {
        File dest = Mock()
        dest.getAbsolutePath() >> "/output"
        dest
    }

        testFile('build.gradle') << '''
            task copy(type: Copy) {
                from('src') {
                    into project.repositories
                }
                into 'dest'
            }
'''

        ExecutionFailure failure = inTestDirectory().withTasks('copy').runWithFailure()
        failure.assertHasCause("""Cannot convert the provided notation to a String: repository container.

	"fmt"
	"reflect"
	"strconv"
	"testing"
)

func TestConverter_byteSlice(t *testing.T) {
	c := NewConverter(nil)
	src := []byte{1, 2, 3}
	dest := []byte{}
	err := c.Convert(&src, &dest, nil)
	if err != nil {
		t.Fatalf("expected no error")
	}
	if e, a := src, dest; !reflect.DeepEqual(e, a) {
		t.Errorf("expected %#v, got %#v", e, a)
	}
}

func TestConverter_MismatchedTypes(t *testing.T) {
	c := NewConverter(nil)

    }

    private void collectTrackers(Set<BuildOperationTracker> dest, List<? extends BuildOperationTracker> trackers) {
        for (BuildOperationTracker tracker : trackers) {
            if (!dest.contains(tracker)) {
                collectTrackers(dest, tracker.getTrackers());
                dest.add(tracker);
            }
        }
    }

    @Override

// which must be a variable to which this field's value can be assigned.
func Field(v reflect.Value, fieldName string, dest interface{}) error {
	field := v.FieldByName(fieldName)
	if !field.IsValid() {
		return fmt.Errorf("couldn't find %v field in %T", fieldName, v.Interface())
	}
	destValue, err := conversion.EnforcePtr(dest)
	if err != nil {
		return err
	}

						src    echo.Instance
						dest   echo.Instances
						expect bool
					}{
						{
							src:    client,
							dest:   serverNakedFoo,
							expect: true,
						},
						{
							src:    client,
							dest:   serverNakedBar,
							expect: false,
						},
					}

					for _, tc := range cases {
						verify(t, tc.src, tc.dest, scheme.HTTP, tc.expect)
					}
				})