// to other allocations that happen during this test we may still see some physical
	// memory over-use.
	overuse := (float64(heapBacked) - float64(stats.HeapAlloc)) / float64(stats.HeapAlloc)
	// Check against our overuse threshold, which is what the scavenger always reserves
	// to encourage allocation of memory that doesn't need to be faulted in.
	//

// which can be important when retaining only a small substring
// of a much larger string. Using Clone can help such programs
// use less memory. Of course, since using Clone makes a copy,
// overuse of Clone can make programs use more memory.
// Clone should typically be used only rarely, and only when
// profiling indicates that it is needed.
// For strings of length zero the string "" will be returned

	It has no effect on other platforms. disablethp is meant for compatibility with versions
	of Go before 1.21, which stopped working around a Linux kernel default that can result
	in significant memory overuse. See https://go.dev/issue/64332. This setting will be
	removed in a future release, so operators should tweak their Linux configuration to suit
	their needs before then. See https://go.dev/doc/gc-guide#Linux_transparent_huge_pages.

 */

package org.gradle.kotlin.dsl.execution

import org.gradle.internal.classpath.ClassPath


internal
interface CompiledScript {
    val program: Class<*>
    val classPath: ClassPath

    fun onReuse()

    }

    @Override
    public boolean defines(Class<?> clazz) {
        return localClassLoader.equals(clazz.getClassLoader());
    }

    @Override
    public void onReuse() {
        parent.onReuse();
        listener.childScopeCreated(parent.getId(), id, origin);
        listener.classloaderCreated(id, id.localId(), localClassLoader, classPath, classpathImplementationHash);
    }

    @Override

     */
    boolean getHasMethods();

    Class<? extends T> loadClass();

    D getData();

    /**
     * Called when this script is reused in a new build invocation.
     */
    void onReuse();

			jobPresentInCJActiveStatus: true,
		},

		// Controller should fail to schedule these, as there are too many missed starting times
		// and either no deadline or a too long deadline.
		"prev ran but done, long overdue, not past deadline, A": {
			concurrencyPolicy:          "Allow",
			schedule:                   onTheHour,
			deadline:                   longDead,
			ranPreviously:              true,

) {

    private
    val cache: CrossBuildInMemoryCache<ProgramId, CompiledScript> = cacheFactory.newCache()

    fun get(key: ProgramId): CompiledScript? =
        cache.getIfPresent(key)?.also { it.onReuse() }

    fun put(key: ProgramId, loadedScriptClass: CompiledScript) {
        cache.put(key, loadedScriptClass)
    }

    }

    @Override
    public ClassLoaderScope lock() {
        return this;
    }

    @Override
    public boolean isLocked() {
        return true;
    }

    @Override
    public void onReuse() {
        // Nothing to do
    }

    @app.get("/items/")
    def read_items() -> List[Item]:
        return [
            Item(
                name="Portal Gun",
                description="Device to travel through the multi-rick-verse",
                sub=SubItem(subname="subname"),
            ),
            Item(name="Plumbus"),
        ]

    client = TestClient(app)
    return client


def test_create_item():