lastOnline      time.Time
	lastHCAt        time.Time
	offlineDuration time.Duration
	latency         latencyStat
}

// isOffline returns current liveness result of remote target. Add endpoint to
// healthCheck map if missing and default to online status
func (sys *BucketTargetSys) isOffline(ep *url.URL) bool {
	sys.hMutex.RLock()
	defer sys.hMutex.RUnlock()
	if h, ok := sys.hc[ep.Host]; ok {
		return !h.Online
	}

                    throw new GradleException("tests.bwc.git_fetch_latest must be [true] or [false] but was [" + fetchProp + "]");
                });
            fetchLatest.onlyIf(t -> project.getGradle().getStartParameter().isOffline() == false && gitFetchLatest.get());
            fetchLatest.dependsOn(addRemoteTaskProvider);
            fetchLatest.setWorkingDir(gitExtension.getCheckoutDir().get());

    }

    public List<String> getPluginGroups() {
        return request.getPluginGroups();
    }

    public boolean isOffline() {
        return request.isOffline();
    }

    public MavenProject getTopLevelProject() {
        return topLevelProject;
    }

    public MavenExecutionResult getResult() {
        return result;
    }

        copy.setLocalRepository(original.getLocalRepository());
        copy.setLocalRepositoryPath(original.getLocalRepositoryPath());
        copy.setOffline(original.isOffline());
        copy.setInteractiveMode(original.isInteractiveMode());
        copy.setCacheNotFound(original.isCacheNotFound());
        copy.setCacheTransferError(original.isCacheTransferError());

    // Interactive
    MavenExecutionRequest setInteractiveMode(boolean interactive);

    boolean isInteractiveMode();

    // Offline
    MavenExecutionRequest setOffline(boolean offline);

    boolean isOffline();

    boolean isCacheTransferError();

    MavenExecutionRequest setCacheTransferError(boolean cacheTransferError);

    boolean isCacheNotFound();

            throws MavenExecutionRequestPopulationException {
        if (settings == null) {
            return request;
        }

        request.setOffline(settings.isOffline());

        request.setInteractiveMode(settings.isInteractiveMode());

        request.setPluginGroups(settings.getPluginGroups());

        request.setLocalRepositoryPath(settings.getLocalRepository());

        configProps.put("maven.startTime", request.getStartTime());
        configProps.put(Constants.MAVEN_START_INSTANT, request.getStartInstant());

        sessionBuilder.setOffline(request.isOffline());
        sessionBuilder.setChecksumPolicy(request.getGlobalChecksumPolicy());
        sessionBuilder.setUpdatePolicy(
                request.isNoSnapshotUpdates()

        ArtifactRepository localRepo = request.getLocalRepository();
        List<ArtifactRepository> remoteRepositories = request.getRemoteRepositories();

        if (!request.isOffline()) {
            Date localCopyLastModified = null;
            if (metadata.getBaseVersion() != null) {
                localCopyLastModified = getLocalCopyLastModified(localRepo, metadata);
            }

    private void injectSession(MetadataResolutionRequest request) {
        RepositorySystemSession session = legacySupport.getRepositorySession();

        if (session != null) {
            request.setOffline(session.isOffline());
            request.setForceUpdate(RepositoryPolicy.UPDATE_POLICY_ALWAYS.equals(session.getUpdatePolicy()));
        }
    }

    @Override
    public ResolutionGroup retrieve(

            throw new LifecycleExecutionException(messageBuilderFactory, mojoExecution, null, cause);
        }

        if (mojoDescriptor.isOnlineRequired() && session.isOffline()) {
            if (MojoExecution.Source.CLI.equals(mojoExecution.getSource())) {
                Throwable cause = new IllegalStateException(