print 'update remote script'
        """

        and:
        executer.withArgument("--offline")
        configurationCacheRun 'ok'

        then:
        configurationCache.assertStateStored()

        and:
        outputDoesNotContain 'update remote script'

        when:
        executer.withArgument("--offline")
        configurationCacheRun 'ok'

        then:

import java.net.ServerSocket
import java.net.Socket
import java.util.concurrent.Executor
import java.util.concurrent.ThreadFactory


fun BindingsBuilder.unsupportedTypes() {

    // Live JVM state
    bind(unsupported<ClassLoader>())
    bind(unsupported<Thread>())
    bind(unsupported<ThreadFactory>())
    bind(unsupported<Executor>())
    bind(unsupported<FileDescriptor>())
    bind(unsupported<RandomAccessFile>())

func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)

// CompareAndSwapInt32 executes the compare-and-swap operation for an int32 value.
// Consider using the more ergonomic and less error-prone [Int32.CompareAndSwap] instead.
func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)

// CompareAndSwapInt64 executes the compare-and-swap operation for an int64 value.

        run 'help'

        then:
        fixture.assertStateLoaded()
    }

    def "can enable with a property in gradle user home gradle.properties"() {
        given:
        executer.requireOwnGradleUserHomeDir()
        executer.gradleUserHomeDir.file('gradle.properties') << """
            $ENABLE_GRADLE_PROP
        """

        when:
        run 'help'

        then:
        fixture.assertStateStored()

 * limitations under the License.
 */

package org.gradle.internal.cc.impl

import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.OutputScrapingExecutionResult
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions
import org.gradle.test.preconditions.UnitTestPreconditions

          <velocityBasedir>${project.basedir}/../src/mdo</velocityBasedir>
        </configuration>
        <executions>
          <execution>
            <id>modello</id>
            <goals>
              <goal>velocity</goal>
              <goal>xsd</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

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

import org.gradle.internal.cc.impl.fixtures.ToolingApiBackedGradleExecuter
import org.gradle.internal.cc.impl.fixtures.ToolingApiSpec
import org.gradle.integtests.fixtures.executer.GradleExecuter

class AbstractIsolatedProjectsToolingApiIntegrationTest extends AbstractIsolatedProjectsIntegrationTest implements ToolingApiSpec {
    @Override
    GradleExecuter createExecuter() {

            owner.with {
                m2.execute(executer)
                m2.mavenRepo().module("thing", "lib1", "2.1").publishWithChangedContent()
            }
        }

        @Override
        void publishWithDifferentDependencies(AbstractIntegrationSpec owner) {
            owner.with {
                m2.execute(executer)

 * compatible type of `this`.
 *
 * @param T the plugin type.
 * @see [PluginAware.apply]
 */
inline fun <reified T : Plugin<Project>> Project.apply() =
    (this as PluginAware).apply<T>()


/**
 * Executes the given configuration block against the [project extension]
 * [org.gradle.api.plugins.ExtensionAware] of the specified type.
 *
 * If no extension is found, configures a project convention if available.

    public static final String ENABLE_CLI = "-D${PROPERTY_NAME}=true"
    final def fixture = new IsolatedProjectsFixture(this)

    void withIsolatedProjects() {
        executer.withArgument(ENABLE_CLI)
    }

    void isolatedProjectsRun(String... tasks) {
        run(ENABLE_CLI, *tasks)
    }

    void isolatedProjectsFails(String... tasks) {
        fails(ENABLE_CLI, *tasks)
    }