return daemonInfo.getState() == Idle;
        }
    });

    @SuppressWarnings("unchecked")
    private final Spec<DaemonInfo> busySpec = Specs.<DaemonInfo>intersect(allSpec, new Spec<DaemonInfo>() {
        public boolean isSatisfiedBy(DaemonInfo daemonInfo) {
            return daemonInfo.getState() != Idle;
        }
    });

    @SuppressWarnings("unchecked")

		n.methods = methods
		n.loader = nil
	}

	n.setState(complete)
	return n
}

// state atomically accesses the current state of the receiver.
func (n *Named) state() namedState {
	return namedState(atomic.LoadUint32(&n.state_))
}

// setState atomically stores the given state for n.
// Must only be called while holding n.mu.
func (n *Named) setState(state namedState) {

            return fileSystemAccess.readRegularFileContentHash(sourceFile.getAbsolutePath())
                .map(fileContent -> {
                    SourceFileState previousState = previous.getState(sourceFile);

                    if (previousState != null) {
                        // Already seen this source file before. See if we can reuse the analysis from last time

                        if (lenient != null) {
                            setState(lenient, ComponentGraphSpecificResolveState.EMPTY_STATE);
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }

    public void setState(ComponentGraphResolveState state, ComponentGraphSpecificResolveState graphState) {

                return daemonInfo.getState() == Idle;
            }
        });
    }

    @Override
    public List<DaemonInfo> getNotIdle() {
        return getDaemonsMatching(new Spec<DaemonInfo>() {
            @Override
            public boolean isSatisfiedBy(DaemonInfo daemonInfo) {
                return daemonInfo.getState() != Idle;
            }
        });
    }

        ComponentState rootComponent = rootModule.getVersion(moduleVersionId, componentId);
        rootComponent.setRoot();
        rootComponent.setState(rootComponentState, ComponentGraphSpecificResolveState.EMPTY_STATE);
        rootModule.select(rootComponent);

		bodyFunc.Body.List = append(bodyFunc.Body.List, r.setState(abi.RF_PANIC, start))
	}

	// Original loop body (already rewritten by editStmt during inspect).
	bodyFunc.Body.List = append(bodyFunc.Body.List, body...)

	// end of loop body, set state to abi.RF_READY and return true to continue iteration
	if r.checkFuncMisuse() {
		bodyFunc.Body.List = append(bodyFunc.Body.List, r.setState(abi.RF_READY, end))
	}

    }

    @Override
    public ModelRuleDescriptor getDescriptor() {
        return descriptor;
    }

    @Override
    public ModelNode.State getState() {
        return state;
    }

    public void setState(ModelNode.State state) {
        this.state = state;
    }

    @Override
    public boolean isMutable() {
        return state.mutable;
    }

    @Nullable

        0 * listener2.onDiscovered(_)
    }

    def node(String path, Class<?> type = String, State state = State.Discovered) {
        def node = new TestNode(path, type)
        node.setState(state)
        return node
    }

    def root() {
        return node("", Void, State.Created)
    }

    private ModelListener allAcceptingListener() {
        return Mock(ModelListener) {

			// Now we create a new bar, which will have the remaining components
			p.bar = createBar()
			return
		}
		p.SetMessage(p.createStatus(p.bar.Width()), false)
	}
}

func (p *Log) SetState(state InstallState) {
	p.mu.Lock()
	defer p.mu.Unlock()
	p.state = state
	switch p.state {
	case StatePruning:
		p.bar.SetTemplateString(inProgress + `Pruning removed resources`)
		p.bar.Write()