* deterministic.
 *
 * This class ensures that at most one thread is running at a time. This is initially the JUnit test
 * thread, which yields its execution privilege while calling [runTasks], [runNextTask], or
 * [advanceUntil]. These functions don't return until the task threads are all idle.
 *
 * Task threads release their execution privilege in these ways:
 *

 * you want to throw away the class loader. For example, dynamically reloading a web application or
 * unloading an OSGi bundle.
 *
 * <p>{@code com.google.common.base.FinalizableReferenceQueue} loads this class in its own class
 * loader. That way, this class doesn't prevent the main class loader from getting garbage
 * collected, and this class can detect when the main class loader has been garbage collected and
 * stop itself.
 */

        size,
        getMultiset().size());
  }

  /** Call the {@code setCount()} method under test, and check its return value. */
  abstract void setCountCheckReturnValue(E element, int count);

  /**
   * Call the {@code setCount()} method under test, but do not check its return value. Callers
   * should use this method over {@link #setCountCheckReturnValue(Object, int)} when they expect

            // Refreshing the original must not clear the clone's cached subject
            orig.refresh();
            // Clone should retain its cached Subject
            assertSame(copySubj, copy.getSubject(), "Clone should retain its cached Subject");
        } else {
            // If JAAS is not configured and getSubject() returns null, verify cloning still works

    </dependency>
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-transport-file</artifactId>
    </dependency>
    <!-- HTTP/1.1, lowest priority, Java8+ (still must as some ITs force it) -->
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-transport-wagon</artifactId>
    </dependency>
    <!-- HTTP/1.1, medium priority, Java8+ -->

If the nested type is a managed type (Gradle can generate its implementation), you can define a nested property with:
```
interface NestedType {
    Property<String> getSomeProperty()
}
class Example {
    @Nested
    NestedType getNestedProperty()
}
```

 *
 * <ul>
 *   <li>{@link #reset} is called (removing the data in this stream and deleting the file), or...
 *   <li>this stream (or, more precisely, its {@link #asByteSource} view) is garbage collected,
 *       <strong>AND</strong> this stream was constructed with {@linkplain
 *       #FileBackedOutputStream(int, boolean) the two-arg constructor} with {@code true} for the

Even if they are all in `localhost`, they use different protocols or ports, so, they are different "origins".

## Steps { #steps }

So, let's say you have a frontend running in your browser at `http://localhost:8080`, and its JavaScript is trying to communicate with a backend running at `http://localhost` (because we don't specify a port, the browser will assume the default port `80`).

                                           TF_DataType dtype, TF_Shape shape,
                                           TF_Status* s);

// Create an operation suitable to use with the provided context. The operation
// requires its type (e.g. "AddV2") to be set independently.
TF_AbstractOp* TF_NewAbstractOp(TF_ExecutionContext* ctx);
void TF_DeleteAbstractOp(TF_AbstractOp*);

// TODO(srbs): Add APIs for specifying attrs etc.

                sub.getTasks().register("extractedAssemble", task ->
                // We keep extracted configuration resolvable false to keep
                // resolveAllDependencies simple so we rely only on its build dependencies here.
                task.dependsOn(extractedConfiguration.getAllArtifacts().getBuildDependencies()));
            });
        });
        project.getExtensions().add("distribution_archives", container);