"owner", reference,
		)
		return true, nil, nil
	case err != nil:
		return false, nil, err
	}

	if owner.GetUID() != reference.UID {
		logger.V(5).Info("item's owner is not found, UID mismatch",
			"item", item.identity,
			"owner", reference,
		)
		gc.absentOwnerCache.Add(absentOwnerCacheKey)
		return true, nil, nil
	}
	return false, owner, nil
}

    private void addVisitedNode(ModuleComponentIdentifier module) {
        DependencyGraphNode node = Mock()
        DependencyGraphComponent owner = Mock()
        ComponentResolutionState component = Mock()
        node.owner >> owner
        node.component >> component
        owner.componentId >> module

        visitor.visitNode(node)
    }

    private void addVisitedChangingNode(ModuleComponentIdentifier module) {

            owner.aliasesInProgress.remove(alias);
            ImmutableVersionConstraint version = owner.versionConstraintInterner.intern(DefaultImmutableVersionConstraint.of(versionBuilder));
            DependencyModel model = new DependencyModel(owner.intern(group), owner.intern(name), null, version, owner.currentContext);
            Supplier<DependencyModel> previous = owner.libraries.put(owner.intern(alias), () -> model);

    private final ResourceLockContainer owner;

    public AbstractTrackedResourceLock(String displayName, ResourceLockCoordinationService coordinationService, ResourceLockContainer owner) {
        this.displayName = displayName;
        this.coordinationService = coordinationService;
        this.owner = owner;
    }

    @Override
    public String toString() {

	defer os.RemoveAll(testPath)

	lockRequesterInfo1 := lockRequesterInfo{
		Owner:           "owner",
		Writer:          true,
		UID:             "0123-4567",
		Timestamp:       UTCNow(),
		TimeLastRefresh: UTCNow(),
	}
	lockRequesterInfo2 := lockRequesterInfo{
		Owner:           "owner",
		Writer:          true,
		UID:             "89ab-cdef",
		Timestamp:       UTCNow(),

        _ * task.toString() >> "<task>"
        _ * task.state >> state
        def owner = Stub(ModelObject)
        _ * owner.taskThatOwnsThisObject >> task
        def property = TestUtil.objectFactory().property(String)
        property.attachOwner(owner, Describables.of("<prop>"))
        property.attachProducer(owner)
        property.set("12")
        return property
    }

        keywordRenderer.renderKeyword(analysisSession, keyword, owner, this, printer)
    }

    public fun renderKeywords(analysisSession: KaSession, keywords: List<KtKeywordToken>, owner: KaAnnotated, printer: PrettyPrinter) {
        keywordRenderer.renderKeywords(analysisSession, keywords, owner, this, printer)
    }

 */
public class FreezableAttributeContainer implements AttributeContainerInternal {

    private final Describable owner;

    private AttributeContainerInternal delegate;

    public FreezableAttributeContainer(AttributeContainerInternal delegate, Describable owner) {
        this.delegate = delegate;
        this.owner = owner;
    }

    /**
     * Prevent further mutations to this attribute container.
     */

    }

    public static int depthCompare(Project left, Project right) {
        return depthCompare(owner(left), owner(right));
    }

    public static int depthCompare(ProjectState left, ProjectState right) {
        return Ints.compare(left.getDepth(), right.getDepth());
    }

    private static ProjectState owner(Project project) {
        if (!(project instanceof ProjectInternal)) {

    private final WaitPrecondition owner;
    private final boolean autoRelease;
    private boolean started;
    private boolean received;

    ResourceHandlerWrapper(Lock lock, ResourceExpectation expectation, WaitPrecondition owner, boolean isAutoRelease) {
        this.lock = lock;
        handler = expectation.create(this);
        this.owner = owner;
        this.autoRelease = isAutoRelease;
    }