// LANGUAGE: +ContextReceivers

// MODULE: context

// FILE: context.kt
class Ctx1
class Ctx2

context(Ctx2)
fun useWithCtx2() = 3

context(Ctx1, Ctx2)
class Test {
    fun foo() {
        <caret_context>val x = 1
    }
}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION

              $context_receiver_0: GET_FIELD 'FIELD FIELD_FOR_CLASS_CONTEXT_RECEIVER name:contextReceiverField0 type:<root>.Ctx1 visibility:private [final] declared in <root>.Test' type=<root>.Ctx1 origin=null

		for {
			if time.Now().After(timeout) {
				t.Errorf("Test %q: timed out", test.name)
				break
			}
			if ctrl.queue.Len() > 0 {
				logger.V(5).Info("Non-empty events queue, processing one", "test", test.name, "queueLength", ctrl.queue.Len())
				ctrl.processNextWorkItem(context.TODO())
			}
			if ctrl.queue.Len() > 0 {
				// There is still some work in the queue, process it now
				continue
			}

		},
	}

	for _, test := range tests {
		klog.V(4).Infof("starting test %q", test.name)
		ctrl := NewPlugin()
		if err := addPriorityClasses(ctrl, test.classesBefore); err != nil {
			t.Errorf("Test %q: unable to add object to informer: %v", test.name, err)
		}
		pcName, defaultPriority, _, err := ctrl.getDefaultPriority()
		if err != nil {

	ctx0 := &afterFuncContext{}
	ctx1, cancel := context.WithCancel(ctx0)
	defer cancel()
	ctx0.cancel(context.Canceled)
	<-ctx1.Done()
}

func TestCustomContextAfterFuncTimeout(t *testing.T) {
	ctx0 := &afterFuncContext{}
	ctx1, cancel := context.WithTimeout(ctx0, veryLongDuration)
	defer cancel()
	ctx0.cancel(context.Canceled)
	<-ctx1.Done()
}

	MOVD 0(R19), R0
	MOVD R2, 40(R1)
	MOVD 8(R19), R2
	MOVD R18, R3
	MOVD R0, CTR
	BL (CTR) // Return to AIX loader

	// Launch rt0_go
	MOVD 40(R1), R2
	MOVD R14, R3 // argc
	MOVD R15, R4 // argv
	BL _main(SB)


DEFINE_PPC64X_FUNCDESC(main, _main)
TEXT _main(SB),NOSPLIT,$-8
	MOVD $runtime·rt0_go(SB), R12
	MOVD R12, CTR
	BR (CTR)


TEXT _rt0_ppc64_aix_lib(SB),NOSPLIT,$-8

            if (request.getType() != null) {
                type = session.getSession().getArtifactTypeRegistry().get(request.getType());
            }
            String str1 = request.getClassifier();
            String classifier = str1 != null && !str1.isEmpty()
                    ? request.getClassifier()
                    : type != null ? type.getClassifier() : "";
            String str = request.getExtension();

		if test.updatedPVC != nil {
			ctrl.pvcAddedUpdated(logger, test.updatedPVC)
		}
		switch {
		case test.deletedPod != nil && test.updatedPod != nil && test.deletedPod.Namespace == test.updatedPod.Namespace && test.deletedPod.Name == test.updatedPod.Name:
			ctrl.podAddedDeletedUpdated(logger, test.deletedPod, test.updatedPod, false)
		case test.updatedPod != nil:
			ctrl.podAddedDeletedUpdated(logger, nil, test.updatedPod, false)

	// Synchronous initialization.
	MOVD	$runtime·libpreinit(SB), R12
	MOVD	R12, CTR
	BL	(CTR)

	// Create a new thread to do the runtime initialization and return.
	MOVD	_cgo_sys_thread_create(SB), R12
	CMP	$0, R12
	BEQ	nocgo
	MOVD	$_rt0_ppc64le_linux_lib_go(SB), R3
	MOVD	$0, R4
	MOVD	R12, CTR
	BL	(CTR)
	BR	done

nocgo:
	MOVD	$0x800000, R12                     // stacksize = 8192KB

				return strings.Contains(err.Error(), "Only bound persistent volume claims can be expanded")
			},
		},
	}

	ctrl := newPlugin()
	informerFactory := informers.NewSharedInformerFactory(nil, controller.NoResyncPeriodFunc())
	ctrl.SetExternalKubeInformerFactory(informerFactory)
	err := ctrl.ValidateInitialization()
	if err != nil {
		t.Fatalf("neither pv lister nor storageclass lister can be nil")
	}