}

    def "does not fail when calling get() after producer task has completed"() {
        given:
        def property = propertyWithCompletedProducer()
        def provider = property.filter { it.contains("1") }

        when:
        provider.get()

        then:
        noExceptionThrown()
    }

    def "fails when calling getOrNull() before producer task has completed"() {
        given:

 * are possible and creating a lazy provider can be done by calling
 * one of the factory methods:
 * <ul>
 *     <li>{@link #unsafe()} would create a lazy wrapper which performs no synchronization at all when calling the supplier: it may be called several times concurrently by different threads. Not thread safe!</li>

interface ProblemFactory {
    /**
     * Returns a default location inferred from the calling thread's state.
     */
    fun locationForCaller(consumer: String? = null): PropertyTrace

    /**
     * Creates a problem with the given message and exception.
     *
     * Problem has no documentation, and a default location is inferred from the calling thread's state.
     */

      : xla_compiler_(options) {}

  // Compiles a Tensorflow `function` into an HloModuleProto stored in the
  // XlaCompilationResult pointed to by `result` by calling
  // XlaCompiler::CompileFunction.
  Status Compile(const XlaCompiler::CompileOptions& options,
                 const NameAttrList& function,
                 absl::Span<const XlaArgument> args,

        succeeds(":test:unitTestClasses")
        file("main/build/classes/java/main").assertHasDescendants("Main.class")
        file("tests/build/classes/java/unitTest").assertHasDescendants("Test.class")
    }

    def "calling withSourcesJar is deprecated when the java plugin is not applied"() {
        given:
        buildFile << """
            plugins {
                id 'java-base'
            }

            sourceSets {

 */
public interface ResolutionAccess {

    /**
     * Get the owner of the resolution.
     */
    ResolutionHost getHost();

    /**
     * Get the request attributes for this resolution. Calling this method will lock-in the
     * request attributes from further mutation but will not perform resolution.
     */
    ImmutableAttributes getAttributes();

    /**

    /**
     * {@inheritDoc}
     *
     * <p>
     * This is similar to calling {@link #value(Iterable)} with a <code>null</code> argument.
     * </p>
     */
    @Override
    ListProperty<T> unset();

    /**
     * {@inheritDoc}
     *
     * <p>
     * This is similar to calling {@link #convention(Iterable)} with a <code>null</code> argument.
     * </p>
     */
    @Override

    /**
     * Updates the current value. The function is passed the current value or {@code null} if there is no value, and the function's return value is
     * used as the new value.
     *
     * <p>The calling thread must own the mutable state from which the value is calculated (via {@link ModelContainer#fromMutableState(Function)}). At most a single thread

	BL	runtime·load_g(SB)

	BL	runtime·sigtrampgo<ABIInternal>(SB)

	// TODO(jsing): Restore callee-save registers.

	RET

// These trampolines help convert from Go calling convention to C calling convention.
// They should be called with asmcgocall.
// A pointer to the arguments is passed in R3.
// A single int32 result is returned in R3.
// (For more results, make an args/results structure.)

HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
logging.setLevel(Level.BASIC);
OkHttpClient client = new OkHttpClient.Builder()
  .addInterceptor(logging)
  .build();
```

You can change the log level at any time by calling `setLevel()`.

To log to a custom location, pass a `Logger` instance to the constructor.
```java
HttpLoggingInterceptor logging = new HttpLoggingInterceptor(new Logger() {
  @Override public void log(String message) {