@org.gradle.api.Generated
                    class `MyPluginGroup`(internal val plugins: PluginDependenciesSpec)


                    /**
                     * Plugin ids starting with `my`.
                     */
                    val `PluginDependenciesSpec`.`my`: `MyPluginGroup`
                        get() = `MyPluginGroup`(this)


                    /**

	if err != nil {
		log.Fatalf("Failed to create HTTP server: %v", err)
	}
	// Store the port for test only.
	s.httpPort <- listener.Addr().(*net.TCPAddr).Port
	s.httpServer = &http.Server{Handler: s}

	log.Printf("Starting HTTP server at %s", listener.Addr())
	if err := s.httpServer.Serve(listener); err != nil {
		log.Fatalf("Failed to start HTTP server: %v", err)
	}
}

func (s *JWTServer) startHTTPS(address string, wg *sync.WaitGroup) {

            includeGroup("my.company")
        }
    }
    mavenCentral {
        content {
            // this repository contains everything BUT artifacts with group starting with "my.company"
            excludeGroupByRegex("my\\.company.*")
        }
    }
}
// end::repository-filter[]

// tag::exclusive-repository-filter[]
repositories {

            includeGroup "my.company"
        }
    }
    mavenCentral {
        content {
            // this repository contains everything BUT artifacts with group starting with "my.company"
            excludeGroupByRegex "my\\.company.*"
        }
    }
}
// end::repository-filter[]

// tag::exclusive-repository-filter[]
repositories {

/**
 * Thrown when connected to a stale daemon address.
 *
 * This is thrown instead of using an initial handshake on the connection, to avoid the latency of a round trip to the
 * daemon before starting the build.
 */
public class StaleDaemonAddressException extends DaemonConnectionException {
    public StaleDaemonAddressException(String message, Throwable cause) {
        super(message, cause);
    }

		healthTimeout: healthTimeout,

		lastUpdatedMap:         make(map[v1.IPFamily]time.Time),
		oldestPendingQueuedMap: make(map[v1.IPFamily]time.Time),
		// The node is eligible (and thus the proxy healthy) while it's starting up
		// and until we've processed the first node event that indicates the
		// contrary.
		nodeEligible: true,
	}
}

// Updated should be called when the proxier of the given IP family has successfully updated

            searchClassPath = Collections.emptyList();
        }
        if (classpath.isEmpty()) {
            throw new IllegalStateException("Unable to construct a bootstrap classpath when starting the daemon");
        }

        versionValidator.validate(resolvedJvm);

        List<String> daemonArgs = new ArrayList<>();
        daemonArgs.addAll(getPriorityArgs(daemonParameters.getPriority()));

# Test case for #67623 in go.work files: make sure the errors are
# printed on lines starting with file and line number so they
# can be easily parsed by tools.

cp go.work.repeated.txt go.work
! go list
stderr '^go.work:4: path .* appears multiple times in workspace$'

cp go.work.badgodebug.txt go.work
! go list
stderr '^go.work:3: unknown godebug "foo"$'

cp go.work.unparsable.txt go.work
! go list

        and:
        configurationCacheRun supportedTasks + ["--info"], 1

        then:
        result.assertConfigurationCacheStateLoaded()
        result.output.contains("Starting build in new daemon")
        result.task(":tooling-api:publishLocalPublicationToLocalRepository").outcome == TaskOutcome.SUCCESS
    }

Expected: A failure description which is a string starting with "broken!"
     but: failure descriptions were []''')

        when:
        failure.assertHasCause("broken!")

        then:
        def e3 = thrown(AssertionError)
        e3.message.trim().startsWith('''No matching cause found
Expected: A cause which is a string starting with "broken!"
     but: causes were []''')

        when: