given:
        Task finalizerDep = task("finalizerDep", type: Async)
        Task finalizer = task("finalizer", dependsOn: [finalizerDep])
        Task a = task("a", type: Async, finalizedBy: [finalizer])
        Task finalizerDep2 = task("finalizerDep2", type: Async, dependsOn: [finalizer])
        Task finalizer2 = task("finalizer2", dependsOn: [finalizerDep2])

        Task finalizer1 = task("finalizer1", dependsOn: [finalizerDependency])
        Task finalized1 = task("finalized1", finalizedBy: [finalizer1])
        Task finalizer2 = task("finalizer2")
        Task finalized2 = task("finalized2", finalizedBy: [finalizer2], failure: new RuntimeException("failure"))

        when:
        addToGraphAndPopulate([finalized1, finalized2])

        then:

    def "finalizer task can depend on multiple finalized tasks"() {
        given:
        buildFile '''
            task finalizer(type: BreakingTask) {
                dependsOn 'finalized1', 'finalized2'
            }
            task finalized1(type: BreakingTask) {
                finalizedBy 'finalizer'
            }
            task finalized2(type: BreakingTask) {

			if finptrmask[0] == 0 {
				// Build pointer mask for Finalizer array in block.
				// Check assumptions made in finalizer1 array above.
				if (unsafe.Sizeof(finalizer{}) != 5*goarch.PtrSize ||
					unsafe.Offsetof(finalizer{}.fn) != 0 ||
					unsafe.Offsetof(finalizer{}.arg) != goarch.PtrSize ||
					unsafe.Offsetof(finalizer{}.nret) != 2*goarch.PtrSize ||
					unsafe.Offsetof(finalizer{}.fint) != 3*goarch.PtrSize ||

    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 {

		logger.V(3).Info("Error adding protection finalizer to PV", "PV", klog.KObj(pv), "err", err)
		return err
	}
	logger.V(3).Info("Added protection finalizer to PV", "PV", klog.KObj(pv))
	return nil
}

func (c *Controller) removeFinalizer(ctx context.Context, pv *v1.PersistentVolume) error {
	pvClone := pv.DeepCopy()
	pvClone.ObjectMeta.Finalizers = slice.RemoveString(pvClone.ObjectMeta.Finalizers, volumeutil.PVProtectionFinalizer, nil)

        then:
        0 * _

        and:
        value == someValue()
    }

    def "replaces provider with fixed value when value finalized after value implicitly finalized but not read yet"() {
        def property = propertyWithNoValue()
        def function = Mock(Callable)
        def provider = new DefaultProvider<T>(function)

        given:

        return new CompositeNodeGroup(original.isReachableFromEntryPoint() || finalizers.isReachableFromEntryPoint(), original, finalizers.getFinalizerGroups());
    }

    public static HasFinalizers mergeInto(HasFinalizers original, HasFinalizers finalizers) {

			runtime.SetFinalizer(x, test.fin)

			runtime.KeepAlive(x)

			// Queue the finalizer.
			runtime.GC()
			runtime.GC()

			if !runtime.BlockUntilEmptyFinalizerQueue(int64(time.Second)) {
				t.Fatal("finalizer failed to execute")
			}
			if got := int(regConfirmRun.Load()); got != test.confirmValue {
				t.Fatalf("wrong finalizer executed? got %d, want %d", got, test.confirmValue)
			}
		})
	}

			finalizers = sets.New(iop.GetFinalizers()...)
			finalizers.Delete(finalizer)
			iop.SetFinalizers(sets.SortedList(finalizers))
			finalizerError = r.client.Update(context.TODO(), iop)
		}
		if finalizerError != nil {
			if errors.IsNotFound(finalizerError) {
				scope.Infof("Did not remove finalizer from %s: the object was previously deleted.", iopName)
				metrics.CRDeletionTotal.Increment()
				return reconcile.Result{}, nil