}

GROOT="$(go env GOROOT)"
GPATH="$(go env GOPATH)"
GMODCACHE="$(go env GOMODCACHE)"
ROOT="$PWD"

$@
ls="$(basename $1)"
shift
case "$ls" in
  link)
    log "${ls}\t$(basename ${2})" ;;
  compile)
    f=${@: -1}
    if [[ "$f" =~ "$GMODCACHE" ]]; then
      base="${f/"$GMODCACHE"\//}"
      mod="$(<<< "$base" cut -d@ -f1)"

    }

    @Override
    protected void configureTaskDefaults(Pmd task, String baseName) {
        Configuration configuration = project.getConfigurations().getAt(getConfigurationName());
        configureTaskConventionMapping(configuration, task);
        configureReportsConventionMapping(task, baseName);
        configureToolchains(task);
    }

//go:build unix

package unix

const (
	R_OK = 0x4
	W_OK = 0x2
	X_OK = 0x1

	// NoFollowErrno is the error returned from open/openat called with
	// O_NOFOLLOW flag, when the trailing component (basename) of the path
	// is a symbolic link.
	NoFollowErrno = noFollowErrno

	return strings.Map(func(r rune) rune {
		if r == ' ' || r == '\n' || r == '\r' || r == '\t' {
			return -1
		}
		return r
	}, s)
}

func TestValid(t *testing.T) {
	tests := []struct {
		CaseName
		data string
		ok   bool
	}{
		{Name(""), `foo`, false},
		{Name(""), `}{`, false},
		{Name(""), `{]`, false},
		{Name(""), `{}`, true},
		{Name(""), `{"foo":"bar"}`, true},

        when:
        project.pluginManager.apply(CppApplicationPlugin)

        then:
        project.application instanceof CppApplication
        project.application.baseName.get() == "testApp"
        project.application.cppSource.files == [src] as Set
    }

    def "registers a component for the application"() {
        when:
        project.pluginManager.apply(CppApplicationPlugin)

    }

    private ComponentWithOutputs binary(String name, String taskName) {
        def outputs = fileCollection(taskName)
        def binary = Stub(TestBinary)
        binary.name >> name
        binary.names >> Names.of(name)
        binary.outputs >> outputs
        return binary
    }

    private FileCollection fileCollection(String taskName) {
        def installTask = Stub(Task)

  private final String relationshipName;
  private final String hashName;
  private final ItemReporter itemReporter;
  private final List<ImmutableList<T>> groups = Lists.newArrayList();

  RelationshipTester(
      Equivalence<? super T> equivalence,
      String relationshipName,
      String hashName,
      ItemReporter itemReporter) {
    this.equivalence = checkNotNull(equivalence);

			},
		},
	}

	services1 = []*Service{
		{
			Hostname: "bar",
		},
	}

	services2 = []*Service{
		{
			Hostname: "bar",
			Ports:    port8000,
		},
		{
			Hostname: "barprime",
		},
	}

	services3 = []*Service{
		{
			Hostname: "bar",
			Ports:    port9000,
		},
		{
			Hostname: "barprime",
		},
	}

	services4 = []*Service{
		{

    }
  }

  /** Returns true if [certificate] matches [hostname]. */
  private fun verifyHostname(
    hostname: String,
    certificate: X509Certificate,
  ): Boolean {
    val hostname = hostname.asciiToLowercase()
    return getSubjectAltNames(certificate, ALT_DNS_NAME).any {
      verifyHostname(hostname, it)
    }
  }

  /**

			v1Request: true,
			newEPS: &discovery.EndpointSlice{
				Endpoints: []discovery.Endpoint{
					{Hostname: ptr.To("hostname-1")},
					{Hostname: ptr.To("hostname-1")},
				},
			},
			expectedEPS: &discovery.EndpointSlice{
				Endpoints: []discovery.Endpoint{
					{Hostname: ptr.To("hostname-1")},
					{Hostname: ptr.To("hostname-1")},
				},
			},
		},
		{
			name: "v1beta1 request, without deprecated topology",