- how to deal with resolution from different places like local/remote/workspace
- how to incorporate the metadata processor to start with
- create a hook to programmatically configure the test
- create a plugin processor
- directory
- jar
- hooks for loading

- I could make an annotation that marked another class as its plugin discoverer, I could just add it to

		allErrors = append(allErrors, field.Invalid(fldPath.Child("timeoutSeconds"), *hook.TimeoutSeconds, "the timeout value must be between 1 and 30 seconds"))
	}

	if hook.NamespaceSelector != nil {
		allErrors = append(allErrors, metav1validation.ValidateLabelSelector(hook.NamespaceSelector, labelSelectorValidationOpts, fldPath.Child("namespaceSelector"))...)
	}

	Logf(format string, args ...any)
}

// NewHTTPProxyHandler returns a new HTTPProxyHandler. It accepts an optional
// hook which is called early in the handler to export request state. If the
// hook returns false, the handler returns immediately with a server error.
func NewHTTPProxyHandler(t TB, hook func(req *http.Request) bool) *HTTPProxyHandler {
	// Ensure that this is only used in tests. This code has not been security
	// reviewed.

    /**
     * [afterLeavingAnalysis] hooks into analysis *after* [analyze]'s action has been executed.
     *
     * The signature of [afterLeavingAnalysis] should be kept stable to avoid breaking binary compatibility, since [analyze] is inlined.
     */
    @KaAnalysisApiInternals
    public abstract fun afterLeavingAnalysis(session: KaSession, useSiteElement: KtElement)

    /**

            whenMerged {whenConfiguredObjects++ }
        }
    }
}

tasks.idea {
    doLast {
        assert beforeConfiguredObjects == 3 : "beforeConfigured() hooks should be fired for domain model objects"
        assert whenConfiguredObjects == 3 : "whenConfigured() hooks should be fired for domain model objects"
    }
}
'''
    }

    @Test
    @ToBeFixedForConfigurationCache
    void whenHooksApplyChangesToGeneratedFile() {

                    // following code, but unfortunately the behavior of logging
                    // is undefined in shutdown hooks.
                    // This is because the logging code installs a shutdown hook of its
                    // own. See Cleaner class inside {@link LogManager}.
                    service.shutdown();

		if n > 0 && !hook.called {
			t.Fatal("expected poll.Splice to be called")
		}

		verifySpliceFds(t, serverDown, hook, "dst")
		verifySpliceFds(t, serverUp, hook, "src")

		// poll.Splice is expected to handle the data transmission successfully.
		if !hook.handled || hook.written != int64(size) || hook.err != nil {

package callbacks

import (
	"fmt"
	"reflect"
	"strings"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"gorm.io/gorm/schema"
	"gorm.io/gorm/utils"
)

// BeforeCreate before create hooks
func BeforeCreate(db *gorm.DB) {
	if db.Error == nil && db.Statement.Schema != nil && !db.Statement.SkipHooks && (db.Statement.Schema.BeforeSave || db.Statement.Schema.BeforeCreate) {
		callMethod(db, func(value interface{}, tx *gorm.DB) (called bool) {

,c.hooks.run('after-highlight',r),c.hooks.run('complete',r)},s.postMessage(JSON.stringify({language:r.language,code:r.code,immediateClose:!0}))}else r.highlightedCode=c.highlight(r.code,r.grammar,r.language),c.hooks.run('before-insert',r),r.element.innerHTML=r.highlightedCode,h&&h.call(f),c.hooks.run('after-highlight',r),c.hooks.run('complete',r)},highlight:function(f,g,h){var l={code:f,grammar:g,language:h};return c.hooks.run('before-tokenize',l),l.tokens=c.tokenize(l.code,l.grammar),c.hooks.ru...

apply plugin: "idea"

def hooks = []

idea {
    project {
        ipr {
            beforeMerged {
                assert it.wildcards.contains('!?*.fooBar')
                it.wildcards << '!?*.fooBarTwo'
                hooks << 'before'
            }
            whenMerged {
                assert it.wildcards.contains('!?*.fooBarTwo')
                hooks << 'when'
            }
        }