given:
        file('build.gradle') << """
task foo { doLast { assert false } }
task bar { doLast { assert true } }
"""

        when:
        withConnection {
            it.newBuild().forTasks('foo').withArguments('bar').run()
        }

        then:
        noExceptionThrown()
    }

    def "delete task removes specified files"() {
        file('foo') << "foo"
        file('bar') << "bar"
        file('baz') << "baz"

        buildFile << """
            assert file('foo').exists()
            assert file('bar').exists()
            assert file('baz').exists()

            task clean(type: Delete) {
                delete 'foo'
                delete file('bar')
                delete files('baz')
             }

 * limitations under the License.
 */

package org.gradle.internal.cc.impl

import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertThrows
import org.junit.Assert.assertTrue
import org.junit.Test
import java.util.Collections
import java.util.concurrent.CountDownLatch
import kotlin.concurrent.thread

        } else {
            assert project.parent.path == parentPath
        }
        // Order of children is not guaranteed for Gradle < 2.0
        assert project.children*.path as Set == childPaths as Set
        assert project.projectIdentifier.projectPath == path
        assert project.projectIdentifier.buildIdentifier.rootDir == rootDir
    }

                @Internal abstract RegularFileProperty getBar()

                @TaskAction
                void useIt() {
                    assert foo.asFile.get().name == "foo"
                    assert bar.asFile.get().name == "bar"
                }
            }
            tasks.register("mytask", MyTask) {
                def layout = project.layout

            it.action(new SimpleAction())
                .forTasks("hello", "bye")
                .setStandardOutput(stdOut)
                .run()
        }

        then:
        assert stdOut.toString().contains("hello")
        assert stdOut.toString().contains("bye")
    }

    def "tasks are run before action is executed"() {
        when:
        def stdOut = new ByteArrayOutputStream()

	verifyGetByIP := func(ip string, expected []*model.WorkloadInstance) {
		assert.Equal(t, expected, index.GetByIP(ip))
	}

	// GetByIP should return 2 workload instances

	verifyGetByIP("2.2.2.2", []*model.WorkloadInstance{wi3, wi1})

	// Delete should return previously inserted value

	deleted := index.Delete(wi1)
	assert.Equal(t, wi1, deleted)

	// GetByIP should return 1 workload instance

            unpackOperations.each {
                assert !it.children
            }
            pullOperations.each {
                if (it.descriptor.displayName.contains('local')) {
                    assert unpackOperations.containsAll(it.children)
                } else {
                    assert !it.children
                }
            }
        } else {

new org.gradle.test.BuildClass()

println 'quiet message'
logging.captureStandardOutput(LogLevel.ERROR)
println 'error message'
assert settings != null
// TODO:configuration-cache consider restoring assertion on the relationship
//  between buildscript.classLoader and getClas().classLoader
assert getClass().classLoader.parent == Thread.currentThread().contextClassLoader
Gradle.class.classLoader.loadClass('${implClassName}')
try {

        def result = executer.usingExecutable('gradlew').withTasks('hello').run()

        assert result.output.contains("hello from $executionVersion.version.version")
        assert result.output.contains("using distribution at ${executer.gradleUserHomeDir.file("wrapper/dists")}")
        assert result.output.contains("using Gradle user home at $executer.gradleUserHomeDir")
    }