arch: Arch = Arch.AMD64,
    testJavaVersion: String = os.perfTestJavaVersion.major.toString(),
    testJavaVendor: String = os.perfTestJavaVendor.name.lowercase(),
) = listOf(
    "$task${if (extraParameters.isEmpty()) "" else " $extraParameters"}",
    "-PperformanceBaselines=$baselines",
    "-PtestJavaVersion=$testJavaVersion",
    "-PtestJavaVendor=$testJavaVendor",
    "-PautoDownloadAndroidStudio=true",

        for (final byte element : digest) {
            final String tmp = Integer.toHexString(element & 0xff);
            if (tmp.length() == 1) {
                buffer.append('0').append(tmp);
            } else {
                buffer.append(tmp);
            }
        }
        return buffer.toString();
    }

    val mediaType = "text/plain;charset=\"'utf-8'\"".toMediaType()
    if (isAndroid) {
      // Charset.forName("'utf-8'") == UTF-8
      assertEquals("UTF-8", mediaType.charsetName())
    } else {
      assertNull(mediaType.charset())
    }
  }

  @Test fun testDefaultCharset() {
    val noCharset = parse("text/plain")
    assertEquals(
      "UTF-8",
      noCharset.charset(Charsets.UTF_8)!!.name(),

      } catch (e: Throwable) {
        failure = e
      }

      if (entry.input in knownFailures) {
        if (failure == null) failures += AssertionError("known failure didn't fail: $entry")
      } else {
        if (failure != null) failures += failure
      }
    }

    if (failures.isNotEmpty()) {
      for (failure in failures) {
        println(failure)
      }
      throw failures.first()
    }

                if (i > 0) {
                    buf.append(", ");
                }
                buf.append(Array.get(obj, i));
            }
            buf.append(']');
            str = buf.toString();
        } else {
            str = String.valueOf(obj);
        }
        return str;
    }

                    currentSegment = new TaskSegment(aggregating);
                    taskSegments.add(currentSegment);
                }

                currentSegment.getTasks().add(new GoalTask(task));
            } else {
                // lifecycle phase
                if (currentSegment == null || currentSegment.isAggregating()) {
                    currentSegment = new TaskSegment(false);

	useOneByte      bool
}

func (rr *recordTransform) Read(p []byte) (n int, err error) {
	if rr.useOneByte {
		p[0] = rr.oneByte[0]
		rr.useOneByte = false
		n, err = rr.reader.Read(p[1:])
		n++
	} else {
		n, err = rr.reader.Read(p)
	}

	if err != nil {
		return n, err
	}

	// Do nothing if record-delimiter is already newline.
	if string(rr.recordDelimiter) == "\n" {
		return n, nil
	}

            if (Files.exists(upgradedPropertiesJson)) {
                Files.copy(upgradedPropertiesJson, to.getAsFile().get().toPath(), StandardCopyOption.REPLACE_EXISTING);
            } else {
                to.getAsFile().get().delete();
            }
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    targetSdk = 34
    unitTests.isIncludeAndroidResources = true
  }

  kotlinOptions {
    jvmTarget = JavaVersion.VERSION_11.toString()
  }

  // issue merging due to conflict with httpclient and something else
  packagingOptions.resources.excludes += setOf(
    "META-INF/DEPENDENCIES",
    "META-INF/LICENSE.md",
    "META-INF/LICENSE-notice.md",
    "README.txt",
    "org/bouncycastle/LICENSE",

    val event = nextEvent() as Failure
    if (code != null) {
      assertThat(event.response?.code).isEqualTo(code)
    }
    if (message != null) {
      assertThat(event.message).isEqualTo(message)
    } else {
      assertThat(event.t).isNull()
    }
  }

  internal data class Open(
    val eventSource: EventSource,
    val response: Response,
  )

  internal data class Failure(