final Optional<Integer> column = this.pointer();

        if (sourcePath.isPresent() && line.isPresent() && column.isPresent()) {
            return sourcePath.get() + ":" + line.get() + ":" + (column.get() + 1);
        } else if (sourcePath.isPresent() && line.isPresent()) {
            return sourcePath.get() + ":" + line.get();
        } else {
            return sourcePath.orElse("");

        def provider = factory.provide(PasswordCredentials, 'myService')

        when:
        def isPresent = provider.isPresent()

        then:
        noExceptionThrown()
        !isPresent
    }

    def "describes single missing property"() {
        given:
        providerFactory.gradleProperty('myServiceUsername') >> Providers.notDefined()

        def provider = layout.projectDirectory.dir(pathProvider)
        !provider.present
        provider.getOrNull() == null
    }

    def "regular file is not present when path provider is not present"() {
        def pathProvider = withNoValue()

        expect:
        def provider = layout.projectDirectory.file(pathProvider)
        !provider.present
        provider.getOrNull() == null
    }

        then:
        def e3 = thrown(IllegalStateException)
        e3.message == 'The value for <c> is final and cannot be changed any further.'

        where:
        method << ["get", "finalizeValue", "isPresent"]
    }

    Property<String> elementProperty() {
        return new DefaultProperty<String>(host, String)
    }

      if (array[i] == target) {
        return i;
      }
    }
    return -1;
  }

  /**
   * Returns the least value present in {@code array}.
   *
   * @param array a <i>nonempty</i> array of {@code int} values
   * @return the value present in {@code array} that is less than or equal to every other value in
   *     the array
   * @throws IllegalArgumentException if {@code array} is empty
   */

            assert junitResult.getSuiteStandardOutput("OkTest").isPresent()
            assert junitResult.getTestCaseStandardOutput("OkTest", "isOk()").isPresent()
        } else {
            assert !junitResult.getSuiteStandardOutput("OkTest").isPresent() // isEmpty not available in Java 8
            assert !junitResult.getTestCaseStandardOutput("OkTest", "isOk()").isPresent()
        }
        if (standardErrIncluded) {

            assert junitResult.getSuiteStandardOutput("FooTest").isPresent()
            assert junitResult.getTestCaseStandardOutput("FooTest", "m1").isPresent()
        } else {
            assert !junitResult.getSuiteStandardOutput("FooTest").isPresent() // isEmpty not available in Java 8
            assert !junitResult.getTestCaseStandardOutput("FooTest", "m1").isPresent()
        }
        if (standardErrIncluded) {

        given:
        def property = propertyWithNoValue()

        expect:
        !property.isPresent()
        !property.isFinalized()
    }

    def "finalization checking works with simple values"() {
        given:
        def property = propertyWithValue(someValue())

        expect:
        property.isPresent()
        !property.isFinalized()

        when:
        property.set(someOtherValue())

def TfExecutor_Dialect : Dialect {
  let name = "tf_executor";

  let description = [{
    The TensorFlow Executor dialect.

    This dialect models the TensorFlow executor semantics and can represent
    arbitrary TensorFlow graphs. As such it follows the existing execution model
    that includes deadness propagation, concurrent semantics, and control
    dependencies.

  @CheckForNull @LazyInit private List<@Nullable Present<V>> values;

  CollectionFuture(
      ImmutableCollection<? extends ListenableFuture<? extends V>> futures,
      boolean allMustSucceed) {
    super(futures, allMustSucceed, true);

    List<@Nullable Present<V>> values =
        futures.isEmpty()
            ? Collections.<@Nullable Present<V>>emptyList()
            : Lists.<@Nullable Present<V>>newArrayListWithCapacity(futures.size());