return
		}

		if _, dup := loading.LoadOrStore(dedupKey{m, pruning}, nil); dup {
			// m has already been enqueued for loading. Since unpruned loading may
			// follow cycles in the requirement graph, we need to return early
			// to avoid making the load queue infinitely long.
			return
		}

		loadQueue.Add(func() {
			summary, err := loadOne(m)
			if err != nil {

        then:
        result.assertCurrentVersionHasNotRegressed()

        where:
        daemon | action
        hot    | loading
        hot    | storing
        cold   | loading
        cold   | storing
    }

    static String loading = "loading"
    static String storing = "storing"
    static String hot = "hot"
    static String cold = "cold"

        }
    }

    /**
     * Call this when an error occurs during class loading.
     * This method only records the error but doesn't throw any exceptions.
     * The exception will be rethrown (wrapped in a ClassNotFoundException) when this thread enters or exits the class loading scope.
     * <p>

     * Prefer returning {@code null} instead of the {@code classfileBuffer} to continue loading the original bytecode.
     * <p>
     * Throwing the exception from this method aborts the transformation but doesn't affect class loading. The caller
     * (the agent) will catch all throwables thrown by this method and forward them to {@link #transformFailed(String, Throwable)}.
     * <p>

                    assertNoScriptCompile(rootBuildFile.stage1)
                    assertNoScriptCompile(rootBuildFile.stage2)
                }
                // then: no compilation nor class loading
                compilationCache {
                    hits(leftBuildFile, rootBuildFile, rightBuildFile)
                }
                classLoadingCache {

import java.util.concurrent.atomic.AtomicLong;

/**
 * Creates unique ids for objects created during configuration.
 * <p>
 * Usage of this factory in object factories ensures that ids are reused consistently when loading from the configuration cache.
 */
@ThreadSafe
@ServiceScope(Scope.BuildTree.class)
public class ConfigurationCacheableIdFactory {

    private static final long USED_ASSIGNED_ID_MARKER = -1;

                @org.junit.jupiter.api.Test
                public void myTest() { }
            }
        """

        when:

import org.gradle.internal.service.scopes.ServiceScope;

import javax.annotation.concurrent.ThreadSafe;

/**
 * Transform step node factory that ensures that unique ids are used correctly
 * when creating new instances and/or loading from the configuration cache.
 */
@ThreadSafe
@ServiceScope(Scope.BuildTree.class)
public class TransformStepNodeFactory {

    private final ConfigurationCacheableIdFactory idFactory;

    }

    @Test(expected = IllegalStateException::class)
    fun `updating state after loading throws`() {
        tracker.loadFrom(emptyEnvironmentState())

        tracker.systemPropertyRemoved("some.property")
    }

    @Test(expected = IllegalStateException::class)
    fun `loading twice throws`() {
        tracker.loadFrom(emptyEnvironmentState())
        tracker.loadFrom(emptyEnvironmentState())

to go.sum and removes any unnecessary ones.

The -v flag causes tidy to print information about removed modules
to standard error.

The -e flag causes tidy to attempt to proceed despite errors
encountered while loading packages.

The -diff flag causes tidy not to modify go.mod or go.sum but
instead print the necessary changes as a unified diff. It exits
with a non-zero code if the diff is not empty.