Assume.assumeTrue(previous.version >= GradleVersion.version('5.0'))

        given:
        precompiledGroovyPluginBuiltWith(version(getCurrent()))

        when:
        def result = pluginTaskExecutedWith(version(getPrevious())).run()

        then:
        result.output.contains("$PLUGIN_ID applied")

                    owner.lockAcquired(this);
                } catch (RuntimeException e) {
                    releaseLock();
                    throw e;
                }
                coordinationService.getCurrent().registerLocked(this);
                return true;
            } else {
                return false;
            }
        } else {
            return true;
        }
    }

    @Override

        this.document = document
        this.parent = parent
    }

    protected Element createNode(Object name) {
        Element element = document.createElement(name as String)
        if (getCurrent() == null) {
            elements << element
            parent?.appendChild(element)
        }
        return element
    }

    protected Element createNode(Object name, Map attributes) {

     * of a {@link #withStateLock(InternalTransformer)} transform.
     *
     * @return the current {@link ResourceLockState} or null if not in a transform.
     */
    @Nullable
    ResourceLockState getCurrent();

    /**
     * Attempts to atomically change the state of resource locks.  Only one thread can alter the resource lock

            }
        }
    }

    @Override
    public void assertHasStateLock() {
        synchronized (lock) {
            if (getCurrent() == null) {
                throw new IllegalStateException();
            }
        }
    }

    @Override
    public void addLockReleaseListener(Action<ResourceLock> listener) {
        synchronized (lock) {

        try (PreparedStatement statement = connection.prepareStatement(insertStatement("testOperation", "testExecution", "version", "totalTime"))) {
            addOperations(statement, testId, null, results.getCurrent());
            for (BaselineVersion baselineVersion : results.getBaselineVersions()) {
                addOperations(statement, testId, baselineVersion.getVersion(), baselineVersion.getResults());
            }

	// update running pod and container count
	updateRunningPodAndContainerMetrics(pods)
	g.podRecords.setCurrent(pods)

	// Compare the old and the current pods, and generate events.
	eventsByPodID := map[types.UID][]*PodLifecycleEvent{}
	for pid := range g.podRecords {
		oldPod := g.podRecords.getOld(pid)
		pod := g.podRecords.getCurrent(pid)
		// Get all containers in the old and the new pod.

    def "target of reference is realized when used as an input"() {
        when:
        buildScript '''
            @Managed
            interface Platforms {
                OperatingSystem getCurrent()
                void setCurrent(OperatingSystem os)

                OperatingSystem getWindows()
                OperatingSystem getLinux()
            }

            @Managed
            interface OperatingSystem {

            @Override
            ResourceLockState.Disposition transform(ResourceLockState resourcesLockState) {
                assert coordinationService.getCurrent() == resourcesLockState
                return FINISHED
            }
        })

        then:
        noExceptionThrown()
    }

    def "locks are rolled back when an exception is thrown"() {

  # Run the task as the same user who is currently running this script.
  $principal = New-ScheduledTaskPrincipal $([System.Security.Principal.WindowsIdentity]::GetCurrent().Name)
  # Just use the default task settings.
  $settings = New-ScheduledTaskSettingsSet
  # Create the ScheduledTask object from the above parameters.