def jdt = parseJdtFile()
        assert jdt.contains('targetPlatform=1.3')
        assert jdt.contains('source=1.4')
    }

    @ToBeFixedForConfigurationCache
    void "allows custom matcher resource filter"() {
        given:
        buildScript """
apply plugin: 'java'
apply plugin: 'eclipse'

eclipse {
  project {
    resourceFilter {
      appliesTo = 'FILES_AND_FOLDERS'

    /**
     * Allows lazy access to the contents of the given file.
     *
     * When the file contents are read at configuration time the file is automatically considered
     * as an input to the configuration model.
     *
     * @param file the file whose contents to read.
     * @return an interface that allows lazy access to the contents of the given file.
     *

# Once moved out of experimental, these will be stable.
# The idea behind a separate public/ directory is to make apparent
# which headers are part of TF's public interface (and which headers)
# are implementation details. This structure allows us to also perform future
# programmatic checks that all "public" headers only include other "public"
# headers.

load("//tensorflow/core/platform:rules_cc.bzl", "cc_library")

package(

import org.gradle.api.InvalidUserDataException
import spock.lang.Specification

class DefaultTestFilterTest extends Specification {

    def spec = new DefaultTestFilter()

    def "allows configuring test names"() {
        expect: spec.includePatterns.isEmpty()

        when:
        spec.includeTestsMatching("*fooMethod")
        spec.includeTestsMatching("*.FooTest.*")

@Timeout(60)
class ConcurrentSpec extends Specification {
    final TestLogger logger = new TestLogger()

    /**
     * An object that allows instants to be defined and queried.
     *
     * @see NamedInstant
     */
    final Instants instant = new Instants(logger)

    /**
     * An object that allows operations to be defined and queried.
     *
     * @see NamedOperation
     */

    return errors::FailedPrecondition(
        "Filesystem allows creation of random access files but no "
        "operations on them have been supplied.");

  if ((ops->filesystem_ops->new_writable_file != nullptr ||
       ops->filesystem_ops->new_appendable_file != nullptr) &&
      ops->writable_file_ops == nullptr)
    return errors::FailedPrecondition(
        "Filesystem allows creation of writable files but no "

import org.gradle.internal.service.scopes.ServiceScope;

import javax.annotation.Nonnull;
import javax.annotation.meta.When;
import java.util.function.Function;

/**
 * A service that allows work graphs to be created, populated and executed.
 */
@ServiceScope(Scope.BuildTree.class)
public interface BuildTreeWorkGraphController {
    /**

 *
 * Not all work benefits from caching: for example tasks that only copy content around on disk rarely do.
 * This annotation allows clearly stating that work does not benefit from caching.
 * It also allows attaching an explanation about why a certain work unit is not made cacheable.
 *

import org.gradle.api.tasks.testing.Test;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Provides access to the configuration of {@link Test} tasks and allows
 * disabling storing their outputs in the build cache.
 */
@ServiceScope(Scope.Project.class)
public interface TestTaskPropertiesService {

    /**
     * Collect the configuration of the given task.
     */

 * limitations under the License.
 */

package org.gradle.api.tasks.scala.internal

import spock.lang.Specification

class ScalaRuntimeHelperTest extends Specification {
    def "allows to find Scala Jar on class path"() {
        when:
        def file = ScalaRuntimeHelper.findScalaJar([new File("other.jar"), new File("scala-jdbc-1.5.jar"), new File("scala-compiler-1.7.jar")], "jdbc")

        then: