*/
  @get:JvmName("proxy") val proxy: Proxy?,
  protocols: List<Protocol>,
  connectionSpecs: List<ConnectionSpec>,
  /**
   * Returns this address's proxy selector. Only used if the proxy is null. If none of this
   * selector's proxies are reachable, a direct connection will be attempted.
   */
  @get:JvmName("proxySelector") val proxySelector: ProxySelector,
) {
  /**

                    // Add the link to the DOM so that it can be clicked
                    downloadLink.href = window.URL.createObjectURL(textFileAsBlob);
                    downloadLink.style.display = "none";
                    document.body.appendChild(downloadLink);

                    downloadLink.click();
                }
            </script>

            determineSubProjectClassTimes(testCoverage, buildProjectClassTimes)?.toMutableMap() ?: return validSubprojects.map { SmallSubprojectBucket(it, ParallelizationMethod.None) }

        validSubprojects.forEach {
            if (!subProjectToClassTimes.containsKey(it.name)) {
                subProjectToClassTimes[it.name] = emptyList()
            }
        }

        val parallelizationMethod = when (testCoverage.os) {
            Os.LINUX -> ParallelizationMethod.TestDistribution
            else -> ParallelizationMethod.None
        }

        return FunctionalTest(
            model,
            testCoverage.getBucketUuid(model, bucketIndex),
            "${testCoverage.asName()} ($startInclusive <= gradle <$endExclusive)",

        tasks.named("test", Test.class).configure(task -> {
            task.getInputs().file(extension.getReleaseNotes().getRenderedDocumentation()).withPropertyName("releaseNotes").withPathSensitivity(PathSensitivity.NONE);

            task.getInputs().property("systemProperties", Collections.emptyMap());
            // TODO: This breaks the provider

                                                    </c:if> <c:if test="${data.endTime==null}">
                                                        <la:message key="labels.none"/>
                                                    </c:if></td>
                                                </tr>
                                            </c:forEach>

func (opts Config) Clone() (int, time.Duration, string) {
	configMutex.RLock()
	defer configMutex.RUnlock()
	return opts.IOCount, opts.Sleep, opts.Bitrot
}

// GetWorkers returns the number of workers, -1 is none configured
func (opts Config) GetWorkers() int {
	configMutex.RLock()
	defer configMutex.RUnlock()
	return opts.DriveWorkers
}

// Update updates opts with nopts
func (opts *Config) Update(nopts Config) {

			}

			for _, kv := range r.Flags.Filter.Tags {
				for t, v := range tagMap {
					if kv.Match(BatchJobKV{Key: t, Value: v}) {
						return true
					}
				}
			}

			// None of the provided tags filter match skip the object
			return false
		}

		if len(r.Flags.Filter.Metadata) > 0 {
			for _, kv := range r.Flags.Filter.Metadata {
				for k, v := range info.Metadata {

    SerializableTester.reserializeAndAssert(Doubles.stringConverter());
  }

  public void testToArray() {
    // need explicit type parameter to avoid javac warning!?
    List<Double> none = Arrays.<Double>asList();
    assertThat(Doubles.toArray(none)).isEqualTo(EMPTY);

    List<Double> one = Arrays.asList((double) 1);
    assertThat(Doubles.toArray(one)).isEqualTo(ARRAY1);

    double[] array = {(double) 0, (double) 1, Math.PI};

  }

  public void testToArray() {
    // need explicit type parameter to avoid javac warning!?
    List<Byte> none = Arrays.<Byte>asList();
    assertThat(Bytes.toArray(none)).isEqualTo(EMPTY);

    List<Byte> one = Arrays.asList((byte) 1);
    assertThat(Bytes.toArray(one)).isEqualTo(ARRAY1);

    byte[] array = {(byte) 0, (byte) 1, (byte) 0x55};