*     cause. At the moment, you can <i>usually</i> still preserve behavior by passing an explicit
   *     {@code null} cause. Note, however, that passing an explicit {@code null} cause prevents
   *     anyone from calling {@link #initCause} later, so it is not quite equivalent to using a
   *     constructor that omits the cause.
   */
  @Deprecated
  protected UncheckedExecutionException() {}

  /**

    protected final OriginMetadataFactory originMetadataFactory;

    public enum BuildCacheMode {
        ENABLED, DISABLED
    }

    public enum RemoteAccessMode {
        ONLINE, OFFLINE
    }

    public AbstractBuildCacheControllerFactory(
        StartParameter startParameter,
        BuildOperationRunner buildOperationRunner,
        OriginMetadataFactory originMetadataFactory,

 *
 * This should only be used on a type that is always assumed to also implement the internal protocol by Gradle internals.
 *
 * This exists to help anyone reading the source code realise that there is an internal component to the type.
 */
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.TYPE})
public @interface HasInternalProtocol {

    }

    def "standard implementation loads CSV correctly"() {
        when:
        PredicatesFile.checkValidNameCombinations(
            ["org.gradle.test.preconditions.UnitTestPreconditions\$Online"] as Set,
            PredicatesFile.DEFAULT_ACCEPTED_COMBINATIONS
        )

        then:
        noExceptionThrown()
    }

    private checkValidCombinations(List<String> combinations) {

        return projectRequired;
    }

    // ----------------------------------------------------------------------
    // Online vs. Offline requirement
    // ----------------------------------------------------------------------

    /**
     * @param requiresOnline <code>true</code> if the Mojo is online, <code>false</code> otherwise.
     */
    public void setOnlineRequired(boolean requiresOnline) {

			}
		case "LastOnline":
			z.LastOnline, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "LastOnline")
				return
			}
		case "Online":
			z.Online, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Online")
				return
			}
		case "Latency":
			err = z.Latency.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Latency")
				return
			}

		clusterDriveMetrics: newClusterStorageInfoCache(),
		nodesUpDown:         newNodesUpDownCache(),
	}
}

type nodesOnline struct {
	Online, Offline int
}

func newNodesUpDownCache() *cachevalue.Cache[nodesOnline] {
	loadNodesUpDown := func(ctx context.Context) (v nodesOnline, err error) {
		v.Online, v.Offline = globalNotificationSys.GetPeerOnlineCount()
		return
	}
	return cachevalue.NewFromFunc(1*time.Minute,

import static org.gradle.internal.logging.LoggingConfigurationBuildOptions.StacktraceOption

@Issue("https://github.com/gradle/gradle/issues/3516")
@Requires(UnitTestPreconditions.Online)
class BuildScanBuildFailureHintIntegrationTest extends AbstractIntegrationSpec {

    private static final List<String> DUMMY_TASK_ONLY = [DUMMY_TASK_NAME]

import org.junit.Assume
import org.junit.AssumptionViolatedException
import spock.lang.Specification
import spock.lang.TempDir

import java.nio.file.Files

@Requires(UnitTestPreconditions.Online)
class MavenDownloaderTest extends Specification {

    @TempDir
    File tmpDir

    def installRoot
    def downloader

    def setup() {

	erasureSetWriteQuorumMD = NewGaugeMD(erasureSetWriteQuorum,
		"Write quorum for the erasure set in a pool", poolIDL, setIDL)
	erasureSetOnlineDrivesCountMD = NewGaugeMD(erasureSetOnlineDrivesCount,
		"Count of online drives in the erasure set in a pool", poolIDL, setIDL)
	erasureSetHealingDrivesCountMD = NewGaugeMD(erasureSetHealingDrivesCount,
		"Count of healing drives in the erasure set in a pool", poolIDL, setIDL)