if (node.isAtLeast(predicate.getState())) {
                    throw new IllegalStateException(String.format("Cannot add rule %s for model element '%s' at state %s as this element is already at state %s.",
                        modelBinding.referrer,
                        node.getPath(),
                        predicate.getState().previous(),
                        node.getState()
                    ));
                }

    }

    @Nullable
    public ModelPath getScope() {
        return reference.getScope();
    }

    public ModelNode.State getState() {
        return reference.getState();
    }

                assertEquals(1, list.getCurrentStartRecordNumber());
                assertEquals(0, list.getOffset());
                assertEquals(10, list.getPageSize());
                assertEquals(0, list.getStart());
                assertEquals("0", list.get(0).get(ID_FIELD));
                assertEquals("9", list.get(9).get(ID_FIELD));
            } else {
                fail();
            }

	return false
}

func makeRaw(fd int) (*State, error) {
	return nil, fmt.Errorf("terminal: MakeRaw not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
}

func getState(fd int) (*State, error) {
	return nil, fmt.Errorf("terminal: GetState not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
}

func restore(fd int, state *State) error {

        def newState = serialized(state)
        newState.fileStates.size() == 2

        def emptyCompileState = newState.getState(fileEmpty)
        emptyCompileState.hash == TestHashCodes.hashCodeFrom(0x12345678)
        emptyCompileState.edges.empty

        def otherCompileState = newState.getState(fileTwo)
        otherCompileState.hash == TestHashCodes.hashCodeFrom(0x23456789)
        otherCompileState.edges == stateTwo.edges
    }

        this.task = task;
    }

    public void mutate(String method, Runnable action) {
        if (!task.getState().isConfigurable()) {
            throw new IllegalStateException(format(method));
        }
        action.run();
    }

    public <T> T mutate(String method, Callable<T> action) {
        if (!task.getState().isConfigurable()) {
            throw new IllegalStateException(format(method));
        }

            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")

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

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

		var throughputHighestResults []SpeedTestResult

		sendResult := func() {
			var result madmin.SpeedTestResult

			durationSecs := opts.duration.Seconds()

			result.GETStats.ThroughputPerSec = throughputHighestGet / uint64(durationSecs)
			result.GETStats.ObjectsPerSec = throughputHighestGet / uint64(opts.objectSize) / uint64(durationSecs)
			result.PUTStats.ThroughputPerSec = throughputHighestPut / uint64(durationSecs)

        def daemonInfo = registry.all.find { it.context.pid == context.pid }
        registry.remove(daemonInfo.address)
        registry.store(new DaemonInfo(daemonInfo.address, daemonInfo.context, "password".bytes, daemonInfo.getState()))
    }

    void assertRegistryNotWorldReadable() {
        def registryFile = new DaemonDir(context.daemonRegistryDir).registry
        if (OperatingSystem.current().isLinux() || OperatingSystem.current().isMacOsX()) {