* point, Finalizer can stop running
     */
    if (!finalizableReferenceClass.getName().equals(FINALIZABLE_REFERENCE)) {
      throw new IllegalArgumentException("Expected " + FINALIZABLE_REFERENCE + ".");
    }

    Finalizer finalizer = new Finalizer(finalizableReferenceClass, queue, frqReference);
    String threadName = Finalizer.class.getName();
    Thread thread = null;

     * point, Finalizer can stop running
     */
    if (!finalizableReferenceClass.getName().equals(FINALIZABLE_REFERENCE)) {
      throw new IllegalArgumentException("Expected " + FINALIZABLE_REFERENCE + ".");
    }

    Finalizer finalizer = new Finalizer(finalizableReferenceClass, queue, frqReference);
    String threadName = Finalizer.class.getName();
    Thread thread = null;

limitations under the License.
*/

package util

const (
	// PVCProtectionFinalizer is the name of finalizer on PVCs that have a running pod.
	PVCProtectionFinalizer = "kubernetes.io/pvc-protection"

	// PVProtectionFinalizer is the name of finalizer on PVs that are bound by PVCs
	PVProtectionFinalizer = "kubernetes.io/pv-protection"

		{
			name:      "pv lacks delete time and finalizer",
			obj:       pv(),
			finalizer: util.PVProtectionFinalizer,
			result:    false,
		},
		{
			name:      "pvc lacks delete time and finalizer",
			obj:       pvc(),
			finalizer: util.PVCProtectionFinalizer,

			result: false,
		},
	}
	for _, test := range tests {
		if test.result != IsDeletionCandidate(test.obj, test.finalizer) {
			t.Error(test.name)
		}
	}
}

    @Requires(IntegTestPreconditions.NotParallelExecutor)
    def "finalizer task dependencies from sibling project must run after finalized task dependencies"() {
        server.start()

        given:
        def configurationCache = newConfigurationCacheFixture()
        createDirs("finalized", "finalizer")
        settingsFile << """
            include 'finalized', 'finalizer'
        """
        buildFile << """

	// if we can't convert the obj to PV, just return
	if !ok {
		return nil
	}
	for _, f := range pv.Finalizers {
		if f == volumeutil.PVProtectionFinalizer {
			// Finalizer is already present, nothing to do
			return nil
		}
	}
	klog.V(4).Infof("adding PV protection finalizer to %s", pv.Name)
	pv.Finalizers = append(pv.Finalizers, volumeutil.PVProtectionFinalizer)

	return nil
}

	require.NoError(t, err)

	// Create a CR with a finalizer.
	ns := "not-the-default"
	name := "foo123"
	noxuResourceClient := newNamespacedCustomResourceClient(ns, dynamicClient, noxuDefinition)

	instance := fixtures.NewNoxuInstance(ns, name)
	instance.SetFinalizers([]string{"noxu.example.com/finalizer"})

	}{
		// PV events
		//
		{
			name:      "PV without finalizer -> finalizer is added",
			updatedPV: pv(),
			expectedActions: []clienttesting.Action{
				clienttesting.NewUpdateAction(pvVer, "", withProtectionFinalizer(pv())),
			},
		},
		{
			name:            "PVC with finalizer -> no action",
			updatedPV:       withProtectionFinalizer(pv()),

	ch := make(chan bool, 10)
	finalize := func(x *int) {
		if *x != 97531 {
			t.Errorf("finalizer %d, want %d", *x, 97531)
		}
		ch <- true
	}

	var finalizerTests = []struct {
		convert   func(*int) any
		finalizer any
	}{
		{func(x *int) any { return x }, func(v *int) { finalize(v) }},
		{func(x *int) any { return Tintptr(x) }, func(v Tintptr) { finalize(v) }},

			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)
			}
		})
	}