// for a single suite. This practice is discouraged, and separate test jobs should be created
// on a per-topology bassis.
// TODO remove this when centralistiod test is isolated as it's own job
func (c *Cluster) OverrideTopology(fn func(cluster.Topology) cluster.Topology) {
	c.Topology = fn(c.Topology)
}

func (c *Cluster) String() string {
	buf := &bytes.Buffer{}

import javax.inject.Inject;

/**
 * Base implementation of {@link CompilerWorkerExecutor} which handles submitting a compile work item to execute.
 * Inheritors need to provide an appropriate isolated worker requirement depending on what isolation mode is being used.
 */
abstract public class AbstractIsolatedCompilerWorkerExecutor implements CompilerWorkerExecutor {
    private final WorkerFactory workerFactory;

        where:
        [forbiddenType, isolationMode] << [[
            Project, // Not isolated
            ProjectLayout, // Not isolated
            Instantiator, // internal
        ], ISOLATION_MODES].combinations()
    }

    def withTestMainParametersAndServices() {

    }

    @Issue("https://github.com/gradle/gradle/issues/10411")
    @Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = "This test requires isolated daemons")
    def "does not leak project state across multiple builds"() {
        fixture.withWorkActionClassInBuildSrc()
        executer.withBuildJvmOpts('-Xms256m', '-Xmx512m').requireIsolatedDaemons().requireDaemon()

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl.isolated


class IsolatedProjectsToolingApiGradleLifecycleIntegrationTest extends AbstractIsolatedProjectsToolingApiIntegrationTest {

    def setup() {
        settingsFile << """
            rootProject.name = 'root'

            // TODO: We should relax this check. For legacy reasons we are not tracking cross-build project
            // dependencies, but we should be. Removing this condition breaks some Isolated Projects tests,
            // so we need to investigate why they are failing and then remove this condition.
            // Specifically, the following test breaks when we remove this check:

            assertThat(
                awaitExceptionFrom(scope),
                sameInstance<Throwable>(expectedFailure)
            )
        }
    }

    @Test
    fun `IOScope failures are isolated`() {

        withAsyncIOScopeFactory {

            // given: a failure in one scope
            val failedScope = newScope().apply {
                io { throw IllegalStateException() }
            }

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl.isolated

class IsolatedProjectsToolingApiInvocationValidationIntegrationTest extends AbstractIsolatedProjectsToolingApiIntegrationTest {
    def "reports cross project access from build script when fetching custom tooling model"() {

                isOffline = false
            },
            equalTo(cacheKeyStringFromStartParameter { })
        )
    }

    @Test
    fun `cache key honours isolated projects option`() {
        assertThat(
            cacheKeyStringFromStartParameter {
                isolatedProjects = Option.Value.value(true)
            },
            equalTo(cacheKeyStringFromStartParameter {

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl.isolated

import org.gradle.internal.cc.impl.fixtures.CustomModel
import org.gradle.tooling.StreamedValueListener
import org.gradle.tooling.model.GradleProject
import org.gradle.tooling.model.eclipse.EclipseProject