* RuntimeException}.
 *
 * <p>Here's an example that tests a {@code finalize} method:
 *
 * <pre>{@code
 * final CountDownLatch latch = new CountDownLatch(1);
 * Object x = new MyClass() {
 *   ...
 *   protected void finalize() { latch.countDown(); ... }
 * };
 * x = null;  // Hint to the JIT that x is stack-unreachable
 * GcFinalization.await(latch);
 * }</pre>

 * RuntimeException}.
 *
 * <p>Here's an example that tests a {@code finalize} method:
 *
 * <pre>{@code
 * final CountDownLatch latch = new CountDownLatch(1);
 * Object x = new MyClass() {
 *   ...
 *   protected void finalize() { latch.countDown(); ... }
 * };
 * x = null;  // Hint to the JIT that x is stack-unreachable
 * GcFinalization.await(latch);
 * }</pre>

                    println("value = " + thing.prop.get())
                }
            }
        """

        when:
        run("show")

        then:
        outputContains("finalize failed with: Cannot finalize the value of extension 'thing' property 'prop' because configuration of root project 'broken' has not completed yet.")
        output.count("value = value 1") == 2
    }

                    println("value = " + thing.prop.files)
                }
            }
        """

        when:
        run("show")

        then:
        outputContains("finalize failed with: Cannot finalize the value of this file collection because configuration of root project 'broken' has not completed yet.")
        output.count("value = [${file('some-file')}]") == 2
    }

    @NotYetImplemented

    def "detects a cycle with a task that mustRunAfter itself as finalizer of another task"() {
        buildFile << """
            def finalizer = tasks.register("finalizer")
            tasks.named("finalizer").configure {
                mustRunAfter(finalizer)
            }
            task myTask {
                finalizedBy finalizer
            }
        """
        expect:
        2.times {

        // A node cannot be cancelled if it belongs to a finalizer group that contains a finalized node that has started execution or that cannot be cancelled, and whose finalizer
        // can potentially still execute
        // So visit all the finalizer groups reachable from groups that the node belongs to and the finalized nodes of those groups
        Set<FinalizerGroup> seen = new HashSet<>();

        0 * closure._
        1 * fileResolver.resolve('a') >> file1
        1 * fileResolver.resolve('b') >> file2
        0 * fileResolver._
    }

    def "can finalize when already finalized"() {
        given:
        def file = new File('one')
        collection.from('a')

        when:
        collection.finalizeValue()

        then:

 * `entryNodes` is not changed by this class.
 *
 * <h2>Note about finalizers</h2>
 * A dependency of a finalizer must not run until it is known to be needed by something else that should run.
 * So if the dependency is only required by a finalizer, then it should not start until the finalizer is ready to start
 * (ie the finalized task has completed). But if the dependency is also required by some node reachable from the

	// Try to queue the object's finalizer that we set earlier.
	GC()
	GC()

	if !BlockUntilEmptyFinalizerQueue(int64(2 * time.Second)) {
		t.Fatal("finalizer queue was never emptied")
	}
	if !finalized.Load() {
		t.Error("expected arena-referenced object to be finalized")
	}
}

func TestUserArenaClearsPointerBits(t *testing.T) {
	// This is a regression test for a serious issue wherein if pointer bits

        0 * configure._
        0 * finalized._

        then:
        1 * finalized.execute(binary1)
        1 * finalized.execute(binary2)
        0 * known._
        0 * configure._
        0 * finalized._
    }

    def "runs actions on element of given type when collection is realized"() {
        def known = Mock(Action)
        def configure = Mock(Action)
        def finalized = Mock(Action)